Termination of the following Term Rewriting System could be proven:

Context-sensitive rewrite system:
The TRS R consists of the following rules:

U11(tt, N, X, XS) → U12(splitAt(N, XS), X)
U12(pair(YS, ZS), X) → pair(cons(X, YS), ZS)
afterNth(N, XS) → snd(splitAt(N, XS))
and(tt, X) → X
fst(pair(X, Y)) → X
head(cons(N, XS)) → N
natsFrom(N) → cons(N, natsFrom(s(N)))
sel(N, XS) → head(afterNth(N, XS))
snd(pair(X, Y)) → Y
splitAt(0, XS) → pair(nil, XS)
splitAt(s(N), cons(X, XS)) → U11(tt, N, X, XS)
tail(cons(N, XS)) → XS
take(N, XS) → fst(splitAt(N, XS))

The replacement map contains the following entries:

U11: {1}
tt: empty set
U12: {1}
splitAt: {1, 2}
pair: {1, 2}
cons: {1}
afterNth: {1, 2}
snd: {1}
and: {1}
fst: {1}
head: {1}
natsFrom: {1}
s: {1}
sel: {1, 2}
0: empty set
nil: empty set
tail: {1}
take: {1, 2}


↳ CSR
  ↳ CSRInnermostProof

Context-sensitive rewrite system:
The TRS R consists of the following rules:

U11(tt, N, X, XS) → U12(splitAt(N, XS), X)
U12(pair(YS, ZS), X) → pair(cons(X, YS), ZS)
afterNth(N, XS) → snd(splitAt(N, XS))
and(tt, X) → X
fst(pair(X, Y)) → X
head(cons(N, XS)) → N
natsFrom(N) → cons(N, natsFrom(s(N)))
sel(N, XS) → head(afterNth(N, XS))
snd(pair(X, Y)) → Y
splitAt(0, XS) → pair(nil, XS)
splitAt(s(N), cons(X, XS)) → U11(tt, N, X, XS)
tail(cons(N, XS)) → XS
take(N, XS) → fst(splitAt(N, XS))

The replacement map contains the following entries:

U11: {1}
tt: empty set
U12: {1}
splitAt: {1, 2}
pair: {1, 2}
cons: {1}
afterNth: {1, 2}
snd: {1}
and: {1}
fst: {1}
head: {1}
natsFrom: {1}
s: {1}
sel: {1, 2}
0: empty set
nil: empty set
tail: {1}
take: {1, 2}

The CSR is orthogonal. By [10] we can switch to innermost.

↳ CSR
  ↳ CSRInnermostProof
    ↳ CSR
      ↳ CSDependencyPairsProof

Context-sensitive rewrite system:
The TRS R consists of the following rules:

U11(tt, N, X, XS) → U12(splitAt(N, XS), X)
U12(pair(YS, ZS), X) → pair(cons(X, YS), ZS)
afterNth(N, XS) → snd(splitAt(N, XS))
and(tt, X) → X
fst(pair(X, Y)) → X
head(cons(N, XS)) → N
natsFrom(N) → cons(N, natsFrom(s(N)))
sel(N, XS) → head(afterNth(N, XS))
snd(pair(X, Y)) → Y
splitAt(0, XS) → pair(nil, XS)
splitAt(s(N), cons(X, XS)) → U11(tt, N, X, XS)
tail(cons(N, XS)) → XS
take(N, XS) → fst(splitAt(N, XS))

The replacement map contains the following entries:

U11: {1}
tt: empty set
U12: {1}
splitAt: {1, 2}
pair: {1, 2}
cons: {1}
afterNth: {1, 2}
snd: {1}
and: {1}
fst: {1}
head: {1}
natsFrom: {1}
s: {1}
sel: {1, 2}
0: empty set
nil: empty set
tail: {1}
take: {1, 2}

Innermost Strategy.

Using Improved CS-DPs we result in the following initial Q-CSDP problem.

↳ CSR
  ↳ CSRInnermostProof
    ↳ CSR
      ↳ CSDependencyPairsProof
        ↳ QCSDP
          ↳ QCSDependencyGraphProof

Q-restricted context-sensitive dependency pair problem:
The symbols in {splitAt, pair, afterNth, snd, fst, head, natsFrom, s, sel, tail, take, SPLITAT, SND, AFTERNTH, HEAD, SEL, FST, TAKE, TAIL, NATSFROM} are replacing on all positions.
For all symbols f in {U11, U12, cons, and, U121, U111, AND} we have µ(f) = {1}.
The symbols in {U} are not replacing on any position.

The ordinary context-sensitive dependency pairs DPo are:

U111(tt, N, X, XS) → U121(splitAt(N, XS), X)
U111(tt, N, X, XS) → SPLITAT(N, XS)
AFTERNTH(N, XS) → SND(splitAt(N, XS))
AFTERNTH(N, XS) → SPLITAT(N, XS)
SEL(N, XS) → HEAD(afterNth(N, XS))
SEL(N, XS) → AFTERNTH(N, XS)
SPLITAT(s(N), cons(X, XS)) → U111(tt, N, X, XS)
TAKE(N, XS) → FST(splitAt(N, XS))
TAKE(N, XS) → SPLITAT(N, XS)

The collapsing dependency pairs are DPc:

U111(tt, N, X, XS) → N
U111(tt, N, X, XS) → XS
U121(pair(YS, ZS), X) → X
AND(tt, X) → X
TAIL(cons(N, XS)) → XS


The hidden terms of R are:

natsFrom(s(N))

Every hiding context is built from:

s on positions {1}
natsFrom on positions {1}

Hence, the new unhiding pairs DPu are :

U111(tt, N, X, XS) → U(N)
U111(tt, N, X, XS) → U(XS)
U121(pair(YS, ZS), X) → U(X)
AND(tt, X) → U(X)
TAIL(cons(N, XS)) → U(XS)
U(s(x_0)) → U(x_0)
U(natsFrom(x_0)) → U(x_0)
U(natsFrom(s(N))) → NATSFROM(s(N))

The TRS R consists of the following rules:

U11(tt, N, X, XS) → U12(splitAt(N, XS), X)
U12(pair(YS, ZS), X) → pair(cons(X, YS), ZS)
afterNth(N, XS) → snd(splitAt(N, XS))
and(tt, X) → X
fst(pair(X, Y)) → X
head(cons(N, XS)) → N
natsFrom(N) → cons(N, natsFrom(s(N)))
sel(N, XS) → head(afterNth(N, XS))
snd(pair(X, Y)) → Y
splitAt(0, XS) → pair(nil, XS)
splitAt(s(N), cons(X, XS)) → U11(tt, N, X, XS)
tail(cons(N, XS)) → XS
take(N, XS) → fst(splitAt(N, XS))

The set Q consists of the following terms:

U11(tt, x0, x1, x2)
U12(pair(x0, x1), x2)
afterNth(x0, x1)
and(tt, x0)
fst(pair(x0, x1))
head(cons(x0, x1))
natsFrom(x0)
sel(x0, x1)
snd(pair(x0, x1))
splitAt(0, x0)
splitAt(s(x0), cons(x1, x2))
tail(cons(x0, x1))
take(x0, x1)


The approximation of the Context-Sensitive Dependency Graph contains 2 SCCs with 11 less nodes.


↳ CSR
  ↳ CSRInnermostProof
    ↳ CSR
      ↳ CSDependencyPairsProof
        ↳ QCSDP
          ↳ QCSDependencyGraphProof
            ↳ AND
              ↳ QCSDP
                ↳ QCSDPSubtermProof
              ↳ QCSDP

Q-restricted context-sensitive dependency pair problem:
The symbols in {splitAt, pair, afterNth, snd, fst, head, natsFrom, s, sel, tail, take} are replacing on all positions.
For all symbols f in {U11, U12, cons, and} we have µ(f) = {1}.
The symbols in {U} are not replacing on any position.

The TRS P consists of the following rules:

U(s(x_0)) → U(x_0)
U(natsFrom(x_0)) → U(x_0)

The TRS R consists of the following rules:

U11(tt, N, X, XS) → U12(splitAt(N, XS), X)
U12(pair(YS, ZS), X) → pair(cons(X, YS), ZS)
afterNth(N, XS) → snd(splitAt(N, XS))
and(tt, X) → X
fst(pair(X, Y)) → X
head(cons(N, XS)) → N
natsFrom(N) → cons(N, natsFrom(s(N)))
sel(N, XS) → head(afterNth(N, XS))
snd(pair(X, Y)) → Y
splitAt(0, XS) → pair(nil, XS)
splitAt(s(N), cons(X, XS)) → U11(tt, N, X, XS)
tail(cons(N, XS)) → XS
take(N, XS) → fst(splitAt(N, XS))

The set Q consists of the following terms:

U11(tt, x0, x1, x2)
U12(pair(x0, x1), x2)
afterNth(x0, x1)
and(tt, x0)
fst(pair(x0, x1))
head(cons(x0, x1))
natsFrom(x0)
sel(x0, x1)
snd(pair(x0, x1))
splitAt(0, x0)
splitAt(s(x0), cons(x1, x2))
tail(cons(x0, x1))
take(x0, x1)


We use the subterm processor [20].


The following pairs can be oriented strictly and are deleted.


U(s(x_0)) → U(x_0)
U(natsFrom(x_0)) → U(x_0)
The remaining pairs can at least be oriented weakly.
none
Used ordering: Combined order from the following AFS and order.
U(x1)  =  x1

Subterm Order


↳ CSR
  ↳ CSRInnermostProof
    ↳ CSR
      ↳ CSDependencyPairsProof
        ↳ QCSDP
          ↳ QCSDependencyGraphProof
            ↳ AND
              ↳ QCSDP
                ↳ QCSDPSubtermProof
                  ↳ QCSDP
                    ↳ PIsEmptyProof
              ↳ QCSDP

Q-restricted context-sensitive dependency pair problem:
The symbols in {splitAt, pair, afterNth, snd, fst, head, natsFrom, s, sel, tail, take} are replacing on all positions.
For all symbols f in {U11, U12, cons, and} we have µ(f) = {1}.

The TRS P consists of the following rules:
none

The TRS R consists of the following rules:

U11(tt, N, X, XS) → U12(splitAt(N, XS), X)
U12(pair(YS, ZS), X) → pair(cons(X, YS), ZS)
afterNth(N, XS) → snd(splitAt(N, XS))
and(tt, X) → X
fst(pair(X, Y)) → X
head(cons(N, XS)) → N
natsFrom(N) → cons(N, natsFrom(s(N)))
sel(N, XS) → head(afterNth(N, XS))
snd(pair(X, Y)) → Y
splitAt(0, XS) → pair(nil, XS)
splitAt(s(N), cons(X, XS)) → U11(tt, N, X, XS)
tail(cons(N, XS)) → XS
take(N, XS) → fst(splitAt(N, XS))

The set Q consists of the following terms:

U11(tt, x0, x1, x2)
U12(pair(x0, x1), x2)
afterNth(x0, x1)
and(tt, x0)
fst(pair(x0, x1))
head(cons(x0, x1))
natsFrom(x0)
sel(x0, x1)
snd(pair(x0, x1))
splitAt(0, x0)
splitAt(s(x0), cons(x1, x2))
tail(cons(x0, x1))
take(x0, x1)


The TRS P is empty. Hence, there is no (P,Q,R,µ)-chain.

↳ CSR
  ↳ CSRInnermostProof
    ↳ CSR
      ↳ CSDependencyPairsProof
        ↳ QCSDP
          ↳ QCSDependencyGraphProof
            ↳ AND
              ↳ QCSDP
              ↳ QCSDP
                ↳ QCSDPSubtermProof

Q-restricted context-sensitive dependency pair problem:
The symbols in {splitAt, pair, afterNth, snd, fst, head, natsFrom, s, sel, tail, take, SPLITAT} are replacing on all positions.
For all symbols f in {U11, U12, cons, and, U111} we have µ(f) = {1}.

The TRS P consists of the following rules:

U111(tt, N, X, XS) → SPLITAT(N, XS)
SPLITAT(s(N), cons(X, XS)) → U111(tt, N, X, XS)

The TRS R consists of the following rules:

U11(tt, N, X, XS) → U12(splitAt(N, XS), X)
U12(pair(YS, ZS), X) → pair(cons(X, YS), ZS)
afterNth(N, XS) → snd(splitAt(N, XS))
and(tt, X) → X
fst(pair(X, Y)) → X
head(cons(N, XS)) → N
natsFrom(N) → cons(N, natsFrom(s(N)))
sel(N, XS) → head(afterNth(N, XS))
snd(pair(X, Y)) → Y
splitAt(0, XS) → pair(nil, XS)
splitAt(s(N), cons(X, XS)) → U11(tt, N, X, XS)
tail(cons(N, XS)) → XS
take(N, XS) → fst(splitAt(N, XS))

The set Q consists of the following terms:

U11(tt, x0, x1, x2)
U12(pair(x0, x1), x2)
afterNth(x0, x1)
and(tt, x0)
fst(pair(x0, x1))
head(cons(x0, x1))
natsFrom(x0)
sel(x0, x1)
snd(pair(x0, x1))
splitAt(0, x0)
splitAt(s(x0), cons(x1, x2))
tail(cons(x0, x1))
take(x0, x1)


We use the subterm processor [20].


The following pairs can be oriented strictly and are deleted.


SPLITAT(s(N), cons(X, XS)) → U111(tt, N, X, XS)
The remaining pairs can at least be oriented weakly.

U111(tt, N, X, XS) → SPLITAT(N, XS)
Used ordering: Combined order from the following AFS and order.
SPLITAT(x1, x2)  =  x1
U111(x1, x2, x3, x4)  =  x2

Subterm Order


↳ CSR
  ↳ CSRInnermostProof
    ↳ CSR
      ↳ CSDependencyPairsProof
        ↳ QCSDP
          ↳ QCSDependencyGraphProof
            ↳ AND
              ↳ QCSDP
              ↳ QCSDP
                ↳ QCSDPSubtermProof
                  ↳ QCSDP
                    ↳ QCSDependencyGraphProof

Q-restricted context-sensitive dependency pair problem:
The symbols in {splitAt, pair, afterNth, snd, fst, head, natsFrom, s, sel, tail, take, SPLITAT} are replacing on all positions.
For all symbols f in {U11, U12, cons, and, U111} we have µ(f) = {1}.

The TRS P consists of the following rules:

U111(tt, N, X, XS) → SPLITAT(N, XS)

The TRS R consists of the following rules:

U11(tt, N, X, XS) → U12(splitAt(N, XS), X)
U12(pair(YS, ZS), X) → pair(cons(X, YS), ZS)
afterNth(N, XS) → snd(splitAt(N, XS))
and(tt, X) → X
fst(pair(X, Y)) → X
head(cons(N, XS)) → N
natsFrom(N) → cons(N, natsFrom(s(N)))
sel(N, XS) → head(afterNth(N, XS))
snd(pair(X, Y)) → Y
splitAt(0, XS) → pair(nil, XS)
splitAt(s(N), cons(X, XS)) → U11(tt, N, X, XS)
tail(cons(N, XS)) → XS
take(N, XS) → fst(splitAt(N, XS))

The set Q consists of the following terms:

U11(tt, x0, x1, x2)
U12(pair(x0, x1), x2)
afterNth(x0, x1)
and(tt, x0)
fst(pair(x0, x1))
head(cons(x0, x1))
natsFrom(x0)
sel(x0, x1)
snd(pair(x0, x1))
splitAt(0, x0)
splitAt(s(x0), cons(x1, x2))
tail(cons(x0, x1))
take(x0, x1)


The approximation of the Context-Sensitive Dependency Graph contains 0 SCCs.